$(function() {
	initDaterange();
})

function initDaterange(){
	//定义locale汉化插件
    var locale = {
        "format": 'YYYY-MM-DD',
        "separator": " -222 ",
        "applyLabel": "确定",
        "cancelLabel": "取消",
        "fromLabel": "起始时间",
        "toLabel": "结束时间'",
        "customRangeLabel": "自定义",
        "weekLabel": "W",
        "daysOfWeek": ["日", "一", "二", "三", "四", "五", "六"],
        "monthNames": ["一月", "二月", "三月", "四月", "五月", "六月", "七月", "八月", "九月", "十月", "十一月", "十二月"],
        "firstDay": 1
    };
    //初始化显示当前时间
    $('#daterange-btn span').html(moment().subtract('hours', 1).format('YYYY-MM-DD') + ' - ' + moment().format('YYYY-MM-DD'));
    //日期控件初始化
    $('#daterange-btn').daterangepicker(
        {
            'locale': locale,
            //汉化按钮部分
            ranges: {
                '今日': [moment(), moment()],
                '昨日': [moment().subtract(1, 'days'), moment().subtract(1, 'days')],
                '最近7日': [moment().subtract(6, 'days'), moment()],
                '最近30日': [moment().subtract(29, 'days'), moment()],
                '本月': [moment().startOf('month'), moment().endOf('month')],
                '上月': [moment().subtract(1, 'month').startOf('month'), moment().subtract(1, 'month').endOf('month')]
           },
            startDate: moment().subtract(29, 'days'),
            endDate: moment()
        },
        function (start, end) {
            $('#daterange-btn span').html(start.format('YYYY-MM-DD') + ' - ' + end.format('YYYY-MM-DD'));
        }
   );
    
}

StringUtils = {  
        isEmpty: function(input) {  
            return input == null || input == '';  
        },  
        isNotEmpty: function(input) {  
            return !this.isEmpty(input);  
        },  
        isBlank: function(input) {  
            return input == null || /^\s*$/.test(input);  
        },  
        isNotBlank: function(input) {  
            return !this.isBlank(input);  
        },  
        trim: function(input) {  
            return input.replace(/^\s+|\s+$/, '');  
        },  
        trimToEmpty: function(input) {  
            return input == null ? "" : this.trim(input);  
        },  
        startsWith: function(input, prefix) {  
            return input.indexOf(prefix) === 0;  
        },  
        endsWith: function(input, suffix) {  
            return input.lastIndexOf(suffix) === 0;  
        },  
        contains: function(input, searchSeq) {  
            return input.indexOf(searchSeq) >= 0;  
        },  
        equals: function(input1, input2) {  
            return input1 == input2;  
        },  
        equalsIgnoreCase: function(input1, input2) {  
            return input1.toLocaleLowerCase() == input2.toLocaleLowerCase();  
        },  
        containsWhitespace: function(input) {  
            return this.contains(input, ' ');  
        },  
        //生成指定个数的字符  
        repeat: function(ch, repeatTimes) {  
            var result = "";  
            for(var i = 0; i < repeatTimes; i++) {  
                result += ch;  
            }  
            return result;  
        },  
        deleteWhitespace: function(input) {  
            return input.replace(/\s+/g, '');  
        },  
        rightPad: function(input, size, padStr) {  
            return input + this.repeat(padStr, size);  
        },  
        leftPad: function(input, size, padStr) {  
            return this.repeat(padStr, size) + input;  
        },  
        //首小写字母转大写  
        capitalize: function(input) {  
            var strLen = 0;  
            if(input == null || (strLen = input.length) == 0) {  
                return input;  
            }  
            return input.replace(/^[a-z]/, function(matchStr) {  
                return matchStr.toLocaleUpperCase();  
            });  
        },  
        //首大写字母转小写  
        uncapitalize: function(input) {  
            var strLen = 0;  
            if(input == null || (strLen = input.length) == 0) {  
                return input;  
            }  
            return input.replace(/^[A-Z]/, function(matchStr) {  
                return matchStr.toLocaleLowerCase();  
            });  
        },  
        //大写转小写，小写转大写  
        swapCase: function(input) {  
            return input.replace(/[a-z]/ig, function(matchStr) {  
                if(matchStr >= 'A' && matchStr <= 'Z') {  
                    return matchStr.toLocaleLowerCase();  
                } else if(matchStr >= 'a' && matchStr <= 'z') {  
                    return matchStr.toLocaleUpperCase();  
                }  
            });  
        },  
        //统计含有的子字符串的个数  
        countMatches: function(input, sub) {  
            if(this.isEmpty(input) || this.isEmpty(sub)) {  
                return 0;  
            }  
            var count = 0;  
            var index = 0;  
            while((index = input.indexOf(sub, index)) != -1) {  
                index += sub.length;  
                count++;  
            }  
            return count;  
        },  
        //只包含字母  
        isAlpha: function(input) {  
            return /^[a-z]+$/i.test(input);  
        },  
        //只包含字母、空格  
        isAlphaSpace: function(input) {  
            return /^[a-z\s]*$/i.test(input);  
        },  
        //只包含字母、数字  
        isAlphanumeric: function(input) {  
            return /^[a-z0-9]+$/i.test(input);  
        },  
        //只包含字母、数字和空格  
        isAlphanumericSpace: function(input) {  
            return /^[a-z0-9\s]*$/i.test(input);  
        },  
        //数字  
        isNumeric: function(input) {  
            return /^(?:[1-9]\d*|0)(?:\.\d+)?$/.test(input);  
        },  
        //小数  
        isDecimal: function(input) {  
            return /^[-+]?(?:0|[1-9]\d*)\.\d+$/.test(input);  
        },  
        //负小数  
        isNegativeDecimal: function(input) {  
            return /^\-?(?:0|[1-9]\d*)\.\d+$/.test(input);  
        },  
        //正小数  
        isPositiveDecimal: function(input) {  
            return /^\+?(?:0|[1-9]\d*)\.\d+$/.test(input);  
        },  
        //整数  
        isInteger: function(input) {  
            return /^[-+]?(?:0|[1-9]\d*)$/.test(input);  
        },  
        //正整数  
        isPositiveInteger: function(input) {  
            return /^\+?(?:0|[1-9]\d*)$/.test(input);  
        },  
        //负整数  
        isNegativeInteger: function(input) {  
            return /^\-?(?:0|[1-9]\d*)$/.test(input);  
        },  
        //只包含数字和空格  
        isNumericSpace: function(input) {  
            return /^[\d\s]*$/.test(input);  
        },  
        isWhitespace: function(input) {  
            return /^\s*$/.test(input);  
        },  
        isAllLowerCase: function(input) {  
            return /^[a-z]+$/.test(input);  
        },  
        isAllUpperCase: function(input) {  
            return /^[A-Z]+$/.test(input);  
        },  
        defaultString: function(input, defaultStr) {  
            return input == null ? defaultStr : input;  
        },  
        defaultIfBlank: function(input, defaultStr) {  
            return this.isBlank(input) ? defaultStr : input;  
        },  
        defaultIfEmpty: function(input, defaultStr) {  
            return this.isEmpty(input) ? defaultStr : input;  
        },  
        //字符串反转  
        reverse: function(input) {  
            if(this.isBlank(input)) {  
                input;  
            }  
            return input.split("").reverse().join("");  
        },  
        //删掉特殊字符(英文状态下)  
        removeSpecialCharacter: function(input) {  
            return input.replace(/[!-/:-@\[-`{-~]/g, "");  
        },  
        //只包含特殊字符、数字和字母（不包括空格，若想包括空格，改为[ -~]）  
        isSpecialCharacterAlphanumeric: function(input) {  
            return /^[!-~]+$/.test(input);  
        },  
        /** 
         * 校验时排除某些字符串，即不能包含某些字符串 
         * @param {Object} conditions:里面有多个属性，如下： 
         *  
         * @param {String} matcherFlag 匹配标识 
         * 0:数字；1：字母；2：小写字母；3:大写字母；4：特殊字符,指英文状态下的标点符号及括号等；5:中文; 
         * 6:数字和字母；7：数字和小写字母；8：数字和大写字母；9：数字、字母和特殊字符；10：数字和中文； 
         * 11：小写字母和特殊字符；12：大写字母和特殊字符；13：字母和特殊字符；14：小写字母和中文；15：大写字母和中文； 
         * 16：字母和中文；17：特殊字符、和中文；18：特殊字符、字母和中文；19：特殊字符、小写字母和中文；20：特殊字符、大写字母和中文； 
         * 100：所有字符; 
         * @param {Array} excludeStrArr 排除的字符串，数组格式 
         * @param {String} length 长度，可为空。1,2表示长度1到2之间；10，表示10个以上字符；5表示长度为5 
         * @param {Boolean} ignoreCase 是否忽略大小写 
         * conditions={matcherFlag:"0",excludeStrArr:[],length:"",ignoreCase:true} 
         */  
        isPatternMustExcludeSomeStr: function(input, conditions) {  
            //参数  
            var matcherFlag = conditions.matcherFlag;  
            var excludeStrArr = conditions.excludeStrArr;  
            var length = conditions.length;  
            var ignoreCase = conditions.ignoreCase;  
            //拼正则  
            var size = excludeStrArr.length;  
            var regex = (size == 0) ? "^" : "^(?!.*(?:{0}))";  
            var subPattern = "";  
            for(var i = 0; i < size; i++) {  
                excludeStrArr[i] = Bee.StringUtils.escapeMetacharacterOfStr(excludeStrArr[i]);  
                subPattern += excludeStrArr[i];  
                if(i != size - 1) {  
                    subPattern += "|";  
                }  
            }  
            regex = this.format(regex, [subPattern]);  
            switch(matcherFlag) {  
                case '0':  
                    regex += "\\d";  
                    break;  
                case '1':  
                    regex += "[a-zA-Z]";  
                    break;  
                case '2':  
                    regex += "[a-z]";  
                    break;  
                case '3':  
                    regex += "[A-Z]";  
                    break;  
                case '4':  
                    regex += "[!-/:-@\[-`{-~]";  
                    break;  
                case '5':  
                    regex += "[\u4E00-\u9FA5]";  
                    break;  
                case '6':  
                    regex += "[a-zA-Z0-9]";  
                    break;  
                case '7':  
                    regex += "[a-z0-9]";  
                    break;  
                case '8':  
                    regex += "[A-Z0-9]";  
                    break;  
                case '9':  
                    regex += "[!-~]";  
                    break;  
                case '10':  
                    regex += "[0-9\u4E00-\u9FA5]";  
                    break;  
                case '11':  
                    regex += "[a-z!-/:-@\[-`{-~]";  
                    break;  
                case '12':  
                    regex += "[A-Z!-/:-@\[-`{-~]";  
                    break;  
                case '13':  
                    regex += "[a-zA-Z!-/:-@\[-`{-~]";  
                    break;  
                case '14':  
                    regex += "[a-z\u4E00-\u9FA5]";  
                    break;  
                case '15':  
                    regex += "[A-Z\u4E00-\u9FA5]";  
                    break;  
                case '16':  
                    regex += "[a-zA-Z\u4E00-\u9FA5]";  
                    break;  
                case '17':  
                    regex += "[\u4E00-\u9FA5!-/:-@\[-`{-~]";  
                    break;  
                case '18':  
                    regex += "[\u4E00-\u9FA5!-~]";  
                    break;  
                case '19':  
                    regex += "[a-z\u4E00-\u9FA5!-/:-@\[-`{-~]";  
                    break;  
                case '20':  
                    regex += "[A-Z\u4E00-\u9FA5!-/:-@\[-`{-~]";  
                    break;  
                case '100':  
                    regex += "[\s\S]";  
                    break;  
                default:  
                    alert(matcherFlag + ":This type is not supported!");  
            }  
            regex += this.isNotBlank(length) ? "{" + length + "}" : "+";  
            regex += "$";  
            var pattern = new RegExp(regex, ignoreCase ? "i" : "");  
            return pattern.test(input);  
        },  
        /** 
         * @param {String} message 
         * @param {Array} arr 
         * 消息格式化 
         */  
        format: function(message, arr) {  
            return message.replace(/{(\d+)}/g, function(matchStr, group1) {  
                return arr[group1];  
            });  
        },  
        /** 
         * 把连续出现多次的字母字符串进行压缩。如输入:aaabbbbcccccd  输出:3a4b5cd 
         * @param {String} input 
         * @param {Boolean} ignoreCase : true or false  
         */  
        compressRepeatedStr: function(input, ignoreCase) {  
            var pattern = new RegExp("([a-z])\\1+", ignoreCase ? "ig" : "g");  
            return result = input.replace(pattern, function(matchStr, group1) {  
                return matchStr.length + group1;  
            });  
        },  
        /** 
         * 校验必须同时包含某些字符串 
         * @param {String} input 
         * @param {Object} conditions:里面有多个属性，如下： 
         *  
         * @param {String} matcherFlag 匹配标识 
         * 0:数字；1：字母；2：小写字母；3:大写字母；4：特殊字符,指英文状态下的标点符号及括号等；5:中文; 
         * 6:数字和字母；7：数字和小写字母；8：数字和大写字母；9：数字、字母和特殊字符；10：数字和中文； 
         * 11：小写字母和特殊字符；12：大写字母和特殊字符；13：字母和特殊字符；14：小写字母和中文；15：大写字母和中文； 
         * 16：字母和中文；17：特殊字符、和中文；18：特殊字符、字母和中文；19：特殊字符、小写字母和中文；20：特殊字符、大写字母和中文； 
         * 100：所有字符; 
         * @param {Array} excludeStrArr 排除的字符串，数组格式 
         * @param {String} length 长度，可为空。1,2表示长度1到2之间；10，表示10个以上字符；5表示长度为5 
         * @param {Boolean} ignoreCase 是否忽略大小写 
         * conditions={matcherFlag:"0",containStrArr:[],length:"",ignoreCase:true} 
         *  
         */  
        isPatternMustContainSomeStr: function(input, conditions) {  
            //参数  
            var matcherFlag = conditions.matcherFlag;  
            var containStrArr = conditions.containStrArr;  
            var length = conditions.length;  
            var ignoreCase = conditions.ignoreCase;  
            //创建正则  
            var size = containStrArr.length;  
            var regex = "^";  
            var subPattern = "";  
            for(var i = 0; i < size; i++) {  
                containStrArr[i] = Bee.StringUtils.escapeMetacharacterOfStr(containStrArr[i]);  
                subPattern += "(?=.*" + containStrArr[i] + ")";  
            }  
            regex += subPattern;  
            switch(matcherFlag) {  
                case '0':  
                    regex += "\\d";  
                    break;  
                case '1':  
                    regex += "[a-zA-Z]";  
                    break;  
                case '2':  
                    regex += "[a-z]";  
                    break;  
                case '3':  
                    regex += "[A-Z]";  
                    break;  
                case '4':  
                    regex += "[!-/:-@\[-`{-~]";  
                    break;  
                case '5':  
                    regex += "[\u4E00-\u9FA5]";  
                    break;  
                case '6':  
                    regex += "[a-zA-Z0-9]";  
                    break;  
                case '7':  
                    regex += "[a-z0-9]";  
                    break;  
                case '8':  
                    regex += "[A-Z0-9]";  
                    break;  
                case '9':  
                    regex += "[!-~]";  
                    break;  
                case '10':  
                    regex += "[0-9\u4E00-\u9FA5]";  
                    break;  
                case '11':  
                    regex += "[a-z!-/:-@\[-`{-~]";  
                    break;  
                case '12':  
                    regex += "[A-Z!-/:-@\[-`{-~]";  
                    break;  
                case '13':  
                    regex += "[a-zA-Z!-/:-@\[-`{-~]";  
                    break;  
                case '14':  
                    regex += "[a-z\u4E00-\u9FA5]";  
                    break;  
                case '15':  
                    regex += "[A-Z\u4E00-\u9FA5]";  
                    break;  
                case '16':  
                    regex += "[a-zA-Z\u4E00-\u9FA5]";  
                    break;  
                case '17':  
                    regex += "[\u4E00-\u9FA5!-/:-@\[-`{-~]";  
                    break;  
                case '18':  
                    regex += "[\u4E00-\u9FA5!-~]";  
                    break;  
                case '19':  
                    regex += "[a-z\u4E00-\u9FA5!-/:-@\[-`{-~]";  
                    break;  
                case '20':  
                    regex += "[A-Z\u4E00-\u9FA5!-/:-@\[-`{-~]";  
                    break;  
                case '100':  
                    regex += "[\s\S]";  
                    break;  
                default:  
                    alert(matcherFlag + ":This type is not supported!");  
            }  
            regex += this.isNotBlank(length) ? "{" + length + "}" : "+";  
            regex += "$";  
            var pattern = new RegExp(regex, ignoreCase ? "i" : "");  
            return pattern.test(input);  
        },  
        //中文校验  
        isChinese: function(input) {  
            return /^[\u4E00-\u9FA5]+$/.test(input);  
        },  
        //去掉中文字符  
        removeChinese: function(input) {  
            return input.replace(/[\u4E00-\u9FA5]+/gm, "");  
        },  
        //转义元字符  
        escapeMetacharacter: function(input) {  
            var metacharacter = "^$()*+.[]|\\-?{}|";  
            if(metacharacter.indexOf(input) >= 0) {  
                input = "\\" + input;  
            }  
            return input;  
        },  
        //转义字符串中的元字符  
        escapeMetacharacterOfStr: function(input) {  
            return input.replace(/[\^\$\*\+\.\|\\\-\?\{\}\|]/gm, "\\$&");  
        }  
  
    }; 